package com.flying.srccode;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName ArrayListSrc
 * @Author flying
 * @Date 2025/1/27 10:23
 * @Description ArrayList源码分析
 */
public class ArrayListSrc {

    @Test
    void test1(){

        /**
         * ArrayList的几个重要属性
         *   DEFAULT_CAPACITY = 10  // 默认的初始容量
         *   EMPTY_ELEMENTDATA = {}
         *   DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
         *   transient Object[] elementData
         *   private int size
         */



        /**
         *     public ArrayList() {
         *         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;   // {}
         *     }
         */
        ArrayList<String> list=new ArrayList<>();  // 进行容器延迟初始化，将容器初始化为空集合


        /**
         *     public boolean add(E e) {
         *         modCount++;        // 内部使用的用于记录容器结构修改的次数   增加/删除/扩容....
         *         add(e, elementData, size);    // 添加元素
         *         return true;   // 添加成功
         *     }
         *
         *
         *     private void add(E e, Object[] elementData, int s) {
         *         if (s == elementData.length)  // 第一次添加元素     s=size:0    elementData.length:0
         *             elementData = grow();     // 进行扩容，扩容的数组容器为 10
         *         elementData[s] = e;   // elementData[0] = e;
         *         size = s + 1;         // size = 0+1  --> 元素个数  ，获取容器内元素个数时，直接将size返回即可
         *     }
         *
         *     private Object[] grow() {
         *         return grow(size + 1);    // 第一次扩容，返回了一个长度为10的数组 elementData
         *     }
         *
         *  private Object[] grow(int minCapacity) {   // size+1   ->  0+1  ->  1
         *     int oldCapacity = elementData.length;   // oldCapacity =  0   ->  数组默认容量：   0
         *
         *     // 代表这个容器不是第一次扩容
         *     if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
         *         int newCapacity = ArraysSupport.newLength(oldCapacity,minCapacity - oldCapacity,oldCapacity >> 1           );
         *         return elementData = Arrays.copyOf(elementData, newCapacity);}
         *     else{
         *     // 容器第一次扩容,
         *     // DEFAULT_CAPACITY=10
         *     // minCapacity = 1
         *     // elementData数组扩容为 10
         *     return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
         *}
         */


        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");


        for (String s : list) {
            System.out.println("s = " + s);
        }

        // 添加第11个元素

        /**
         *   private Object[] grow(int minCapacity) {   // size+1   ->  10+1  ->  11
         *      int oldCapacity = elementData.length;   // oldCapacity =  10   -> 10
         *
         *      // 代表这个容器不是第一次扩容
         *      if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
         *             int newCapacity = ArraysSupport.newLength(
         *             oldCapacity,                   // 原始容量    10
         *             minCapacity - oldCapacity,     // 最小增长    最小容量-旧容量    11-10 -> 1
         *             oldCapacity >> 1               // 首选增长     10/2  ->   5
         *             );
         *
         *             return elementData = Arrays.copyOf(elementData, newCapacity);}
         *         else{
         *         return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];}
         *
         *
         *  // 判断
         *  public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
         *         int prefLength = oldLength + Math.max(minGrowth, prefGrowth);  // 首选长度  10+Math.max(1,5)  --> 15
         *         if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
         *             return prefLength;    -->  15
         *         } else {
         *             // put code cold in a separate method
         *             return hugeLength(oldLength, minGrowth);    -->  minGrowth >= SOFT_MAX_ARRAY_LENGTH?minGrowth:SOFT_MAX_ARRAY_LENGTH （2147483639）
         *         }
         *     }
         */
        list.add("s");
        list.add("s");
        list.add("s");
        list.add("s");

        list.add("a");
        list.add("a");



    }


    @Test
    void test2(){
        ArrayList<String> list=new ArrayList<>();  // 进行容器延迟初始化，将容器初始化为空集合

        list.add("a");
        list.add("b");
        list.add("c");
        list.add(null);
        /**
         *  public boolean remove(Object o) {
         *      final Object[] es = elementData;
         *      final int size = this.size;  // 容器内的元素个数   3
         *      int i = 0;  // 记录查找到的元素的索引
         *      found: {
         *          if (o == null) {
         *              for (; i < size; i++)
         *                  if (es[i] == null)   // 空元素 使用数组索引判断，避免空指针异常
         *                      break found;
         *          } else {
         *              for (; i < size; i++)
         *                  if (o.equals(es[i]))  //  equals() 比较，相同元素，停止外层循环标签
         *                      break found;
         *          }
         *          return false;  // 此种情况，要删除的元素不存在
         *      }
         *      fastRemove(es, i);
         *      return true;
         *  }
         *
         *   private void fastRemove(Object[] es, int i) {
         *      modCount++;
         *      final int newSize;
         *      if ((newSize = size - 1) > i)  //   4-1 >
         *          System.arraycopy(es, i + 1, es, i, newSize - i);
         *      es[size = newSize] = null;
         *   }
         *
         *
         */
        for (String s : list) {
            System.out.println("s = " + s);
        }
        boolean b= list.remove("b");

        System.out.println("=================================");
        for (String s : list) {
            System.out.println("s = " + s);
        }

    }





}
